home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / g / gnu_c / gempp19.zoo / gem++19 / include / gemrawo.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-29  |  5.8 KB  |  163 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  GEMrawobject
  4. //
  5. //  A GEMrawobject is a C++ version of the standard GEM "OBJECT".  It is
  6. //  constructed to have an identical bit image to that object, and as
  7. //  such is only intended as a bridge between the fixed-sized objects
  8. //  of GEM to the variable-sized objects we need for an Object Oriented
  9. //  class hierarchy.  There is no point deriving from a GEMrawobject,
  10. //  since GEM forms are still only arrays of OBJECTs.
  11. //
  12. //  This file is Copyright 1992,1993 by Warwick W. Allison.
  13. //  This file is part of the gem++ library.
  14. //  You are free to copy and modify these sources, provided you acknowledge
  15. //  the origin by retaining this notice, and adhere to the conditions
  16. //  described in the file COPYING.LIB.
  17. //
  18. /////////////////////////////////////////////////////////////////////////////
  19.  
  20. #ifndef GEMrawo_h
  21. #define GEMrawo_h
  22.  
  23. #include <bool.h>
  24. #include <gemfast.h>
  25.  
  26. class GEMobject;
  27.  
  28. class GEMrawobject : private OBJECT
  29. // Since GEMrawobject is derived from OBJECT, and has no new data fields
  30. // or virtual member functions (necessary?), it should be bit-compatible.
  31. {
  32. public:
  33.     // The best thing to do with a GEMrawobject is Cook it.
  34.     // Cook() returns 0 if no GEMobject has been declared for this object.
  35.     GEMobject* Cook();
  36.  
  37.     GEMrawobject() { }
  38.  
  39.     // The top two flag bits define whether a GEMrawobject needs to
  40.     // have a new copy of the object-specific data.
  41.     //
  42.     // If the object is EDITABLE, the logic below is negated, that is
  43.     // ob_spec data is copied by default - setting bits negates the effect.
  44.     //
  45.     // Strings and BITBLKs with flag 15 or 14 set are copied.
  46.     // ICONBLKs with flag 15 is set have the icon text copied.
  47.     // ICONBLKs with flag 14 is set have the icon image copied.
  48.     GEMrawobject(const GEMrawobject&);
  49.  
  50.     // The following are methods suited to different styles
  51.     // Note that the "void" procedure could return the old value, but
  52.     // this seems dangerous, as they would be too similar to the
  53.     // other inspection-only parameterless methods.
  54.     //  Too many choices?
  55.  
  56.     bool Selected(bool s)        { return State(SELECTED,s); }
  57.     bool Selected() const        { return States(SELECTED); }
  58.     void Select()                { Selected(TRUE); }
  59.     void Deselect()                { Selected(FALSE); }
  60.     bool Crossed(bool s)        { return State(CROSSED,s); }
  61.     bool Crossed() const        { return States(CROSSED); }
  62.     void Cross()                { Crossed(TRUE); }
  63.     void Uncross()                { Crossed(FALSE); }
  64.     bool Checked(bool s)        { return State(CHECKED,s); }
  65.     bool Checked() const        { return States(CHECKED); }
  66.     void Check()                { Checked(TRUE); }
  67.     void Uncheck()                { Checked(FALSE); }
  68.     bool Disabled(bool s)        { return State(DISABLED,s); }
  69.     bool Disabled() const        { return States(DISABLED); }
  70.     void Disable()                { Disabled(TRUE); }
  71.     void Enable()                { Disabled(FALSE); }
  72.     bool Outlined(bool s)        { return State(OUTLINED,s); }
  73.     bool Outlined() const        { return States(OUTLINED); }
  74.     void Outline()                { Outlined(TRUE); }
  75.     void Unoutline()            { Outlined(FALSE); }
  76.     bool Shadowed(bool s)        { return State(SHADOWED,s); }
  77.     bool Shadowed() const        { return States(SHADOWED); }
  78.     void Shadow()                { Shadowed(TRUE); }
  79.     void Unshadow()                { Shadowed(FALSE); }
  80.  
  81.     bool Selectable(bool f)        { return Flag(SELECTABLE,f); }
  82.     bool Selectable() const        { return Flags(SELECTABLE); }
  83.     bool Default(bool f)        { return Flag(DEFAULT,f); }
  84.     bool Default() const        { return Flags(DEFAULT); }
  85.     bool Exit(bool f)            { return Flag(EXIT,f); }
  86.     bool Exit() const            { return Flags(EXIT); }
  87.     bool Editable(bool f)        { return Flag(EDITABLE,f); }
  88.     bool Editable() const        { return Flags(EDITABLE); }
  89.     bool RadioButton(bool f)    { return Flag(RBUTTON,f); }
  90.     bool RadioButton() const    { return Flags(RBUTTON); }
  91.     bool LastObject(bool f)        { return Flag(LASTOB,f); }
  92.     bool LastObject() const        { return Flags(LASTOB); }
  93.     bool TouchExit(bool f)        { return Flag(TOUCHEXIT,f); }
  94.     bool TouchExit() const        { return Flags(TOUCHEXIT); }
  95.     bool HideTree(bool f)        { return Flag(HIDETREE,f); }
  96.     bool HideTree() const        { return Flags(HIDETREE); }
  97.     bool Indirect(bool f)        { return Flag(INDIRECT,f); }
  98.     bool Indirect() const        { return Flags(INDIRECT); }
  99.  
  100.     int Head() const            { return ob_head; }
  101.     int Tail() const            { return ob_tail; }
  102.     int Next() const            { return ob_next; }
  103.  
  104.     unsigned long ObjectSpecific() const;
  105.     void ObjectSpecific(unsigned long l);
  106.  
  107.     int Type() const            { return ob_type&0xff; }
  108.     int ExtType() const            { return ob_type>>8; }
  109.     void Type(int t)            { ob_type=ob_type&0xff00|t; }
  110.     void ExtType(int t)            { ob_type=ob_type&0x00ff|(t<<8); }
  111.  
  112.     void MoveTo(short x, short y)    { ob_x=x; ob_y=y; }
  113.     void MoveBy(short x, short y)    { ob_x+=x; ob_y+=y; }
  114.  
  115.     short States() const        { return ob_state; }
  116.     short Flags() const            { return ob_flags; }
  117.  
  118.     short X() const                                { return ob_x; }
  119.     short Y() const                                { return ob_y; }
  120.     void Resize(short w, short h)                { ob_width=w; ob_height=h; }
  121.     short Width() const                            { return ob_width; }
  122.     short Height() const                        { return ob_height; }
  123.  
  124.     char* ImageBitmap(bool Mask=FALSE) const;
  125.     short ImageHeight() const;
  126.     short ImageWidth() const;
  127.     void SetImageBitmap(char* bitmap, short w, short h, bool Mask=FALSE);
  128.     char* Text() const;
  129.     void SetText(char* str);
  130.  
  131.     int FillPattern() const;
  132.     void FillPattern(int);
  133.  
  134.     bool Transparent() const;
  135.     void Transparent(bool);
  136.  
  137.     int Font() const;
  138.     void Font(int font);
  139.  
  140.     int ForeCol() const;
  141.     void ForeCol(int colourindex);
  142.  
  143.     int BackCol() const;
  144.     void BackCol(int colourindex);
  145.  
  146.     int BorderCol() const;
  147.     void BorderCol(int colourindex);
  148.  
  149.     int BorderWidth() const;
  150.     void BorderWidth(int width);
  151.  
  152. private:
  153.     bool State(short s, bool on) { bool t=ob_state&s; if (on)
  154.             ob_state|=s; else ob_state&=~s; return !!t; }
  155.     bool States(short s) const    { return !!(ob_state&s); }
  156.  
  157.     bool Flag(short f, bool on) { bool t=ob_flags&f; if (on)
  158.             ob_flags|=f; else ob_flags&=~f; return !!t;}
  159.     bool Flags(short f) const    { return !!(ob_flags&f); }
  160. };
  161.  
  162. #endif
  163.